Entdecken Sie Property-Based Testing mit Pythons Hypothesis Bibliothek. Gehen Sie über beispielbasierte Tests hinaus, um Edge Cases zu finden und robustere, zuverlässigere Software zu entwickeln.
Jenseits von Unit-Tests: Ein tiefer Einblick in Property-Based Testing mit Pythons Hypothesis
In der Welt der Softwareentwicklung ist das Testen das Fundament der Qualität. Seit Jahrzehnten ist das vorherrschende Paradigma das beispielbasierte Testen. Wir erstellen sorgfältig Eingaben, definieren die erwarteten Ausgaben und schreiben Assertions, um zu überprüfen, ob sich unser Code wie geplant verhält. Dieser Ansatz, der in Frameworks wie unittest und pytest zu finden ist, ist leistungsstark und unerlässlich. Aber was wäre, wenn ich Ihnen sagen würde, dass es einen ergänzenden Ansatz gibt, der Fehler aufdecken kann, an deren Suche Sie noch nicht einmal gedacht haben?
Willkommen in der Welt des Property-Based Testing, einem Paradigma, das den Fokus vom Testen spezifischer Beispiele auf die Überprüfung allgemeiner Eigenschaften Ihres Codes verlagert. Und im Python-Ökosystem ist der unangefochtene Champion dieses Ansatzes eine Bibliothek namens Hypothesis.
Diese umfassende Anleitung führt Sie von einem kompletten Anfänger zu einem sicheren Anwender von Property-Based Testing mit Hypothesis. Wir werden die Kernkonzepte untersuchen, in praktische Beispiele eintauchen und lernen, wie Sie dieses leistungsstarke Tool in Ihren täglichen Entwicklungsablauf integrieren können, um robustere, zuverlässigere und fehlerresistente Software zu entwickeln.
Was ist Property-Based Testing? Ein Umdenken
Um Hypothesis zu verstehen, müssen wir zunächst die grundlegende Idee des Property-Based Testing erfassen. Vergleichen wir es mit dem traditionellen beispielbasierten Testen, das wir alle kennen.
Beispielbasiertes Testen: Der vertraute Weg
Stellen Sie sich vor, Sie haben eine benutzerdefinierte Sortierfunktion my_sort() geschrieben. Beim beispielbasierten Testen wäre Ihr Denkprozess folgender:
- "Testen wir es mit einer einfachen, geordneten Liste." ->
assert my_sort([1, 2, 3]) == [1, 2, 3] - "Was ist mit einer umgekehrt geordneten Liste?" ->
assert my_sort([3, 2, 1]) == [1, 2, 3] - "Was ist mit einer leeren Liste?" ->
assert my_sort([]) == [] - "Eine Liste mit Duplikaten?" ->
assert my_sort([5, 1, 5, 2]) == [1, 2, 5, 5] - "Und eine Liste mit negativen Zahlen?" ->
assert my_sort([-1, -5, 0]) == [-5, -1, 0]
Dies ist effektiv, hat aber eine grundlegende Einschränkung: Sie testen nur die Fälle, an die Sie denken können. Ihre Tests sind nur so gut wie Ihre Vorstellungskraft. Möglicherweise übersehen Sie Edge Cases mit sehr großen Zahlen, Ungenauigkeiten bei Fließkommazahlen, bestimmte Unicode-Zeichen oder komplexe Datenkombinationen, die zu unerwartetem Verhalten führen.
Property-Based Testing: Denken in Invarianten
Property-Based Testing dreht das Drehbuch um. Anstatt spezifische Beispiele zu liefern, definieren Sie die Eigenschaften oder Invarianten Ihrer Funktion – Regeln, die für jede gültige Eingabe gelten sollten. Für unsere Funktion my_sort() könnten diese Eigenschaften sein:
- Die Ausgabe ist sortiert: Für jede Zahlenliste ist jedes Element in der Ausgabeliste kleiner oder gleich dem folgenden.
- Die Ausgabe enthält die gleichen Elemente wie die Eingabe: Die sortierte Liste ist nur eine Permutation der ursprünglichen Liste; es werden keine Elemente hinzugefügt oder verloren.
- Die Funktion ist idempotent: Das Sortieren einer bereits sortierten Liste sollte diese nicht ändern. Das heißt,
my_sort(my_sort(some_list)) == my_sort(some_list).
Bei diesem Ansatz schreiben Sie nicht die Testdaten. Sie schreiben die Regeln. Anschließend lassen Sie ein Framework wie Hypothesis Hunderte oder Tausende von zufälligen, vielfältigen und oft tückischen Eingaben generieren, um zu versuchen, Ihre Eigenschaften zu widerlegen. Wenn es eine Eingabe findet, die eine Eigenschaft verletzt, hat es einen Fehler gefunden.
Einführung in Hypothesis: Ihr automatisierter Testdatengenerator
Hypothesis ist die führende Bibliothek für Property-Based Testing für Python. Sie übernimmt die von Ihnen definierten Eigenschaften und übernimmt die schwere Arbeit der Generierung von Testdaten, um diese herauszufordern. Es ist nicht nur ein Zufallsdatengenerator; es ist ein intelligentes und leistungsstarkes Tool, das entwickelt wurde, um Fehler effizient zu finden.
Hauptmerkmale von Hypothesis
- Automatische Testfallgenerierung: Sie definieren die *Form* der Daten, die Sie benötigen (z. B. "eine Liste von ganzen Zahlen", "eine Zeichenfolge, die nur Buchstaben enthält", "ein Datum in der Zukunft"), und Hypothesis generiert eine Vielzahl von Beispielen, die dieser Form entsprechen.
- Intelligentes Schrumpfen: Dies ist das magische Feature. Wenn Hypothesis einen fehlgeschlagenen Testfall findet (z. B. eine Liste mit 50 komplexen Zahlen, die Ihre Sortierfunktion zum Absturz bringt), meldet es nicht einfach diese riesige Liste. Es vereinfacht die Eingabe auf intelligente und automatische Weise, um das kleinstmögliche Beispiel zu finden, das den Fehler immer noch verursacht. Anstelle einer Liste mit 50 Elementen wird möglicherweise gemeldet, dass der Fehler nur bei
[inf, nan]auftritt. Dies macht das Debuggen unglaublich schnell und effizient. - Nahtlose Integration: Hypothesis lässt sich perfekt in beliebte Testframeworks wie
pytestundunittestintegrieren. Sie können Property-Based Tests neben Ihren vorhandenen beispielbasierten Tests hinzufügen, ohne Ihren Workflow zu ändern. - Umfangreiche Strategiebibliothek: Es enthält eine riesige Sammlung integrierter "Strategien" zum Generieren von allem, von einfachen ganzen Zahlen und Zeichenfolgen bis hin zu komplexen, verschachtelten Datenstrukturen, zeitzonenbewussten Datumsangaben und sogar NumPy-Arrays.
- Zustandsbasiertes Testen: Für komplexere Systeme kann Hypothesis Aktionssequenzen testen, um Fehler in Zustandsübergängen zu finden, was mit beispielbasiertem Testen notorisch schwierig ist.
Erste Schritte: Ihr erster Hypothesis Test
Legen wir los. Der beste Weg, Hypothesis zu verstehen, ist, es in Aktion zu sehen.
Installation
Zuerst müssen Sie Hypothesis und Ihren Test Runner Ihrer Wahl installieren (wir verwenden pytest). Es ist so einfach wie:
pip install pytest hypothesis
Ein einfaches Beispiel: Eine Betragsfunktion
Betrachten wir eine einfache Funktion, die den absoluten Wert einer Zahl berechnen soll. Eine leicht fehlerhafte Implementierung könnte wie folgt aussehen:
# in einer Datei namens `my_math.py`
def custom_abs(x):
"""Eine benutzerdefinierte Implementierung der Betragsfunktion."""
if x < 0:
return -x
return x
Schreiben wir nun eine Testdatei, test_my_math.py. Zuerst der traditionelle pytest Ansatz:
# test_my_math.py (Beispielbasiert)
def test_abs_positive():
assert custom_abs(5) == 5
def test_abs_negative():
assert custom_abs(-5) == 5
def test_abs_zero():
assert custom_abs(0) == 0
Diese Tests bestehen. Unsere Funktion sieht basierend auf diesen Beispielen korrekt aus. Schreiben wir nun einen Property-Based Test mit Hypothesis. Was ist eine Kerneigenschaft der Betragsfunktion? Das Ergebnis sollte niemals negativ sein.
# test_my_math.py (Property-Based mit Hypothesis)
from hypothesis import given
from hypothesis import strategies as st
from my_math import custom_abs
@given(st.integers())
def test_abs_property_is_non_negative(x):
"""Eigenschaft: Der Absolutwert einer ganzen Zahl ist immer >= 0."""
assert custom_abs(x) >= 0
Lass uns das aufschlüsseln:
from hypothesis import given, strategies as st: Wir importieren die notwendigen Komponenten.givenist ein Dekorator, der eine reguläre Testfunktion in einen Property-Based Test verwandelt.strategiesist das Modul, in dem wir unsere Datengeneratoren finden.@given(st.integers()): Dies ist der Kern des Tests. Der Dekorator@givenweist Hypothesis an, diese Testfunktion mehrmals auszuführen. Für jede Ausführung wird ein Wert mithilfe der bereitgestellten Strategiest.integers()generiert und als Argumentxan unsere Testfunktion übergeben.assert custom_abs(x) >= 0: Dies ist unsere Eigenschaft. Wir behaupten, dass für jede ganze Zahlx, die sich Hypothesis ausdenkt, das Ergebnis unserer Funktion größer oder gleich Null sein muss.
Wenn Sie dies mit pytest ausführen, wird es wahrscheinlich für viele Werte bestehen. Hypothesis versucht 0, -1, 1, große positive Zahlen, große negative Zahlen und mehr. Unsere einfache Funktion verarbeitet all dies korrekt. Versuchen wir nun eine andere Strategie, um zu sehen, ob wir eine Schwäche finden können.
# Testen wir mit Fließkommazahlen
@given(st.floats())
def test_abs_floats_property(x):
assert custom_abs(x) >= 0
Wenn Sie dies ausführen, findet Hypothesis schnell einen fehlgeschlagenen Fall!
Falsifying example: test_abs_floats_property(x=nan) ... assert custom_abs(nan) >= 0 AssertionError: assert nan >= 0
Hypothesis hat festgestellt, dass unsere Funktion, wenn sie float('nan') (Not a Number) erhält, nan zurückgibt. Die Assertion nan >= 0 ist falsch. Wir haben gerade einen subtilen Fehler gefunden, an dessen manuelle Prüfung wir wahrscheinlich nicht gedacht hätten. Wir könnten unsere Funktion korrigieren, um diesen Fall zu behandeln, vielleicht indem wir einen ValueError auslösen oder einen bestimmten Wert zurückgeben.
Noch besser, was wäre, wenn der Fehler bei einer sehr spezifischen Float-Zahl liegen würde? Der Shrinker von Hypothesis hätte eine große, komplexe, fehlerhafte Zahl genommen und sie auf die einfachste Version reduziert, die den Fehler immer noch auslöst.
Die Macht der Strategien: Erstellen Sie Ihre Testdaten
Strategien sind das Herzstück von Hypothesis. Sie sind Rezepte zum Generieren von Daten. Die Bibliothek enthält eine riesige Auswahl an integrierten Strategien, und Sie können diese kombinieren und anpassen, um nahezu jede Datenstruktur zu generieren, die Sie sich vorstellen können.
Häufige integrierte Strategien
- Numerisch:
st.integers(min_value=0, max_value=1000): Generiert ganze Zahlen, optional innerhalb eines bestimmten Bereichs.st.floats(min_value=0.0, max_value=1.0, allow_nan=False, allow_infinity=False): Generiert Floats mit detaillierter Kontrolle über Sonderwerte.st.fractions(),st.decimals()
- Text:
st.text(min_size=1, max_size=50): Generiert Unicode-Zeichenfolgen einer bestimmten Länge.st.text(alphabet='abcdef0123456789'): Generiert Zeichenfolgen aus einem bestimmten Zeichensatz (z. B. für Hex-Codes).st.characters(): Generiert einzelne Zeichen.
- Sammlungen:
st.lists(st.integers(), min_size=1): Generiert Listen, in denen jedes Element eine ganze Zahl ist. Beachten Sie, wie wir eine andere Strategie als Argument übergeben! Dies wird als Komposition bezeichnet.st.tuples(st.text(), st.booleans()): Generiert Tupel mit einer festen Struktur.st.sets(st.integers())st.dictionaries(keys=st.text(), values=st.integers()): Generiert Dictionaries mit angegebenen Schlüssel- und Werttypen.
- Temporal:
st.dates(),st.times(),st.datetimes(),st.timedeltas(). Diese können zeitzonenbewusst gemacht werden.
- Sonstiges:
st.booleans(): GeneriertTrueoderFalse.st.just('constant_value'): Generiert immer denselben einzelnen Wert. Nützlich zum Zusammensetzen komplexer Strategien.st.one_of(st.integers(), st.text()): Generiert einen Wert aus einer der bereitgestellten Strategien.st.none(): Generiert nurNone.
Kombinieren und Transformieren von Strategien
Die wahre Stärke von Hypothesis liegt in seiner Fähigkeit, komplexe Strategien aus einfacheren zu erstellen.
Verwenden von .map()
Mit der Methode .map() können Sie einen Wert aus einer Strategie übernehmen und ihn in etwas anderes transformieren. Dies ist perfekt für die Erstellung von Objekten Ihrer benutzerdefinierten Klassen.
# Eine einfache Datenklasse
from dataclasses import dataclass
@dataclass
class User:
user_id: int
username: str
# Eine Strategie zum Generieren von User-Objekten
user_strategy = st.builds(
User,
user_id=st.integers(min_value=1),
username=st.text(min_size=3, alphabet='abcdefghijklmnopqrstuvwxyz')
)
@given(user=user_strategy)
def test_user_creation(user):
assert isinstance(user, User)
assert user.user_id > 0
assert user.username.isalpha()
Verwenden von .filter() und assume()
Manchmal müssen Sie bestimmte generierte Werte ablehnen. Beispielsweise benötigen Sie möglicherweise eine Liste von ganzen Zahlen, deren Summe nicht Null ist. Sie könnten .filter() verwenden:
st.lists(st.integers()).filter(lambda x: sum(x) != 0)
Die Verwendung von .filter() kann jedoch ineffizient sein. Wenn die Bedingung häufig falsch ist, kann Hypothesis lange Zeit damit verbringen, ein gültiges Beispiel zu generieren. Ein besserer Ansatz ist oft die Verwendung von assume() innerhalb Ihrer Testfunktion:
from hypothesis import assume
@given(st.lists(st.integers()))
def test_something_with_non_zero_sum_list(numbers):
assume(sum(numbers) != 0)
# ... Ihre Testlogik hier ...
assume() teilt Hypothesis mit: "Wenn diese Bedingung nicht erfüllt ist, verwerfen Sie dieses Beispiel einfach und versuchen Sie ein neues." Es ist eine direktere und oft leistungsfähigere Möglichkeit, Ihre Testdaten einzuschränken.
Verwenden von st.composite()
Für eine wirklich komplexe Datengenerierung, bei der ein generierter Wert von einem anderen abhängt, ist st.composite() das Tool, das Sie benötigen. Es ermöglicht Ihnen, eine Funktion zu schreiben, die eine spezielle draw-Funktion als Argument verwendet, mit der Sie Schritt für Schritt Werte aus anderen Strategien abrufen können.
Ein klassisches Beispiel ist das Generieren einer Liste und eines gültigen Indexes in dieser Liste.
@st.composite
def list_and_index(draw):
# Zuerst ziehen wir eine nicht leere Liste
my_list = draw(st.lists(st.integers(), min_size=1))
# Dann ziehen wir einen Index, der garantiert für diese Liste gültig ist
index = draw(st.integers(min_value=0, max_value=len(my_list) - 1))
return (my_list, index)
@given(data=list_and_index())
def test_list_access(data):
my_list, index = data
# Dieser Zugriff ist aufgrund der Art und Weise, wie wir die Strategie erstellt haben, garantiert sicher
element = my_list[index]
assert element is not None # Eine einfache Assertion
Hypothesis in Aktion: Reale Szenarien
Wenden wir diese Konzepte auf realistischere Probleme an, mit denen Softwareentwickler jeden Tag konfrontiert sind.
Szenario 1: Testen einer Datenserialisierungsfunktion
Stellen Sie sich eine Funktion vor, die ein Benutzerprofil (ein Dictionary) in eine URL-sichere Zeichenfolge serialisiert und eine andere, die es deserialisiert. Eine Schlüsseleigenschaft ist, dass der Prozess perfekt umkehrbar sein sollte.
import json
import base64
def serialize_profile(data: dict) -> str:
"""Serialisiert ein Dictionary in eine URL-sichere Base64-Zeichenfolge."""
json_string = json.dumps(data)
return base64.urlsafe_b64encode(json_string.encode('utf-8')).decode('utf-8')
def deserialize_profile(encoded_str: str) -> dict:
"""Deserialisiert eine Zeichenfolge zurück in ein Dictionary."""
json_string = base64.urlsafe_b64decode(encoded_str.encode('utf-8')).decode('utf-8')
return json.loads(json_string)
# Nun zum Test
# Wir benötigen eine Strategie, die JSON-kompatible Dictionaries generiert
json_dictionaries = st.dictionaries(
keys=st.text(),
values=st.recursive(st.none() | st.booleans() | st.floats(allow_nan=False) | st.text(),
lambda children: st.lists(children) | st.dictionaries(st.text(), children),
max_leaves=10)
)
@given(profile=json_dictionaries)
def test_serialization_roundtrip(profile):
"""Eigenschaft: Das Deserialisieren eines codierten Profils sollte das ursprüngliche Profil zurückgeben."""
encoded = serialize_profile(profile)
decoded = deserialize_profile(encoded)
assert profile == decoded
Dieser einzelne Test wird unsere Funktionen mit einer riesigen Vielfalt an Daten überfordern: leere Dictionaries, Dictionaries mit verschachtelten Listen, Dictionaries mit Unicode-Zeichen, Dictionaries mit seltsamen Schlüsseln und mehr. Es ist weitaus gründlicher als das Schreiben einiger manueller Beispiele.
Szenario 2: Testen eines Sortieralgorithmus
Kehren wir zu unserem Sortierbeispiel zurück. Hier ist, wie Sie die zuvor definierten Eigenschaften testen würden.
from collections import Counter
def my_buggy_sort(numbers):
# Führen wir einen subtilen Fehler ein: Es werden Duplikate entfernt
return sorted(list(set(numbers)))
@given(st.lists(st.integers()))
def test_sorting_properties(numbers):
sorted_list = my_buggy_sort(numbers)
# Eigenschaft 1: Die Ausgabe ist sortiert
for i in range(len(sorted_list) - 1):
assert sorted_list[i] <= sorted_list[i+1]
# Eigenschaft 2: Die Elemente sind gleich (dies wird den Fehler finden)
assert Counter(numbers) == Counter(sorted_list)
# Eigenschaft 3: Die Funktion ist idempotent
assert my_buggy_sort(sorted_list) == sorted_list
Wenn Sie diesen Test ausführen, findet Hypothesis schnell ein fehlgeschlagenes Beispiel für Eigenschaft 2, z. B. numbers=[0, 0]. Unsere Funktion gibt [0] zurück, und Counter([0, 0]) ist nicht gleich Counter([0]). Der Shrinker stellt sicher, dass das fehlgeschlagene Beispiel so einfach wie möglich ist, wodurch die Ursache des Fehlers sofort ersichtlich wird.
Szenario 3: Zustandsbasiertes Testen
Für Objekte mit internem Zustand, der sich im Laufe der Zeit ändert (wie eine Datenbankverbindung, ein Warenkorb oder ein Cache), kann das Auffinden von Fehlern unglaublich schwierig sein. Möglicherweise ist eine bestimmte Abfolge von Operationen erforderlich, um einen Fehler auszulösen. Hypothesis bietet RuleBasedStateMachine genau zu diesem Zweck.
Stellen Sie sich eine einfache API für einen In-Memory-Schlüsselwertspeicher vor:
class SimpleKeyValueStore:
def __init__(self):
self._data = {}
def set(self, key, value):
self._data[key] = value
def get(self, key):
return self._data.get(key)
def delete(self, key):
if key in self._data:
del self._data[key]
def size(self):
return len(self._data)
Wir können sein Verhalten modellieren und mit einer Zustandsmaschine testen:
from hypothesis.stateful import RuleBasedStateMachine, rule, Bundle
class KeyValueStoreMachine(RuleBasedStateMachine):
def __init__(self):
super().__init__()
self.model = {}
self.sut = SimpleKeyValueStore()
# Bundle() wird verwendet, um Daten zwischen Regeln zu übergeben
keys = Bundle('keys')
@rule(target=keys, key=st.text(), value=st.integers())
def set_key(self, key, value):
self.model[key] = value
self.sut.set(key, value)
return key
@rule(key=keys)
def delete_key(self, key):
del self.model[key]
self.sut.delete(key)
@rule(key=st.text())
def get_key(self, key):
model_val = self.model.get(key)
sut_val = self.sut.get(key)
assert model_val == sut_val
@rule()
def check_size(self):
assert len(self.model) == self.sut.size()
# Um den Test auszuführen, müssen Sie einfach von der Machine und unittest.TestCase ableiten
# In pytest können Sie den Test einfach der Machine-Klasse zuweisen
TestKeyValueStore = KeyValueStoreMachine.TestCase
Hypothesis führt nun zufällige Sequenzen von set_key-, delete_key-, get_key- und check_size-Operationen aus und versucht unerbittlich, eine Sequenz zu finden, die dazu führt, dass eine der Assertions fehlschlägt. Es wird überprüft, ob sich das Abrufen eines gelöschten Schlüssels korrekt verhält, ob die Größe nach mehreren Sets und Löschvorgängen konsistent ist und viele andere Szenarien, an deren manuelle Prüfung Sie möglicherweise nicht denken.
Best Practices und erweiterte Tipps
- Die Beispiel-Datenbank: Hypothesis ist intelligent. Wenn es einen Fehler findet, speichert es das fehlgeschlagene Beispiel in einem lokalen Verzeichnis (
.hypothesis/). Wenn Sie Ihre Tests das nächste Mal ausführen, wird dieses fehlgeschlagene Beispiel zuerst wiedergegeben, sodass Sie sofortiges Feedback erhalten, dass der Fehler weiterhin vorhanden ist. Sobald Sie es behoben haben, wird das Beispiel nicht mehr wiedergegeben. - Steuern der Testausführung mit
@settings: Sie können viele Aspekte der Testausführung mithilfe des Dekorators@settingssteuern. Sie können die Anzahl der Beispiele erhöhen, eine Frist festlegen, wie lange ein einzelnes Beispiel ausgeführt werden kann (um Endlosschleifen abzufangen), und bestimmte Integritätsprüfungen deaktivieren.@settings(max_examples=500, deadline=1000) # Führen Sie 500 Beispiele aus, 1 Sekunde Frist @given(...) ...
- Reproduzieren von Fehlern: Jede Hypothesis-Ausführung gibt einen Seed-Wert aus (z. B.
@reproduce_failure('version', 'seed')). Wenn ein CI-Server einen Fehler findet, den Sie lokal nicht reproduzieren können, können Sie diesen Dekorator mit dem bereitgestellten Seed verwenden, um Hypothesis zu zwingen, genau dieselbe Abfolge von Beispielen auszuführen. - Integration mit CI/CD: Hypothesis ist perfekt für jede Continuous-Integration-Pipeline geeignet. Seine Fähigkeit, obskure Fehler zu finden, bevor sie die Produktion erreichen, macht es zu einem unschätzbaren Sicherheitsnetz.
Das Umdenken: Denken in Eigenschaften
Die Einführung von Hypothesis ist mehr als nur das Erlernen einer neuen Bibliothek; es geht darum, eine neue Denkweise über die Korrektheit Ihres Codes anzunehmen. Anstatt zu fragen: "Welche Eingaben soll ich testen?", fragen Sie sich: "Was sind die universellen Wahrheiten über diesen Code?"
Hier sind einige Fragen, die Sie bei der Identifizierung von Eigenschaften unterstützen sollen:
- Gibt es eine umgekehrte Operation? (z. B. serialisieren/deserialisieren, verschlüsseln/entschlüsseln, komprimieren/dekomprimieren). Die Eigenschaft ist, dass die Durchführung der Operation und ihrer Umkehrung die ursprüngliche Eingabe ergeben sollte.
- Ist die Operation idempotent? (z. B.
abs(abs(x)) == abs(x)). Das mehrmalige Anwenden der Funktion sollte das gleiche Ergebnis liefern wie das einmalige Anwenden. - Gibt es eine andere, einfachere Möglichkeit, dasselbe Ergebnis zu berechnen? Sie können testen, ob Ihre komplexe, optimierte Funktion die gleiche Ausgabe wie eine einfache, offensichtlich korrekte Version erzeugt (z. B. Testen Ihrer ausgefallenen Sortierung mit der integrierten Python-Funktion
sorted()). - Was sollte an der Ausgabe immer wahr sein? (z. B. Die Ausgabe einer Funktion
find_prime_factorssollte nur Primzahlen enthalten, und ihr Produkt sollte der Eingabe entsprechen). - Wie ändert sich der Zustand? (Für zustandsbasiertes Testen) Welche Invarianten müssen nach jeder gültigen Operation beibehalten werden? (z. B. Die Anzahl der Artikel in einem Warenkorb darf niemals negativ sein).
Fazit: Ein neues Maß an Vertrauen
Property-Based Testing mit Hypothesis ersetzt nicht das beispielbasierte Testen. Sie benötigen weiterhin spezifische, handgeschriebene Tests für kritische Geschäftslogik und gut verstandene Anforderungen (z. B. "Ein Benutzer aus Land X muss Preis Y sehen").
Was Hypothesis bietet, ist eine leistungsstarke, automatisierte Möglichkeit, das Verhalten Ihres Codes zu untersuchen und sich vor unvorhergesehenen Edge Cases zu schützen. Es fungiert als unermüdlicher Partner, der Tausende von Tests generiert, die vielfältiger und tückischer sind, als ein Mensch realistischerweise schreiben könnte. Indem Sie die grundlegenden Eigenschaften Ihres Codes definieren, erstellen Sie eine robuste Spezifikation, anhand derer Hypothesis testen kann, wodurch Sie ein neues Maß an Vertrauen in Ihre Software erhalten.
Wenn Sie das nächste Mal eine Funktion schreiben, nehmen Sie sich einen Moment Zeit, um über die Beispiele hinauszudenken. Fragen Sie sich: "Was sind die Regeln? Was muss immer wahr sein?" Lassen Sie dann Hypothesis die harte Arbeit erledigen und versuchen Sie, diese zu brechen. Sie werden überrascht sein, was es findet, und Ihr Code wird dadurch besser.